/**
 * 《缙青年》电子期刊 - 主页脚本
 * 开发者：缙云公司—韩剑
 */

// 主页管理器
const BookListManager = {
    // 初始化
    init() {
        this.loadingContainer = Utils.dom.$('#loadingContainer');
        this.booksContainer = Utils.dom.$('#booksContainer');
        this.booksGrid = Utils.dom.$('#booksGrid');
        this.emptyState = Utils.dom.$('#emptyState');

        this.booksCount = Utils.dom.$('#booksCount');

        // 状态变量
        this.allBooks = []; // 所有书籍数据

        // 清理过期缓存
        this.cleanExpiredCache();

        // 绑定事件
        this.bindEvents();

        // 检查是否有缓存数据
        this.checkCacheAndLoad();
    },

    // 检查缓存并加载
    async checkCacheAndLoad() {
        try {
            // 尝试从缓存加载
            const cachedBooks = this.getCachedBooksData();

            if (cachedBooks && cachedBooks.length > 0) {
                console.log('从缓存加载书籍列表');
                this.updateLoadingText('正在从缓存加载...');

                // 保存所有书籍数据
                this.allBooks = cachedBooks;

                // 显示缓存的书籍
                this.renderBooks(this.allBooks);
                this.showBooks();

                // 在后台更新数据
                setTimeout(() => {
                    this.refreshBooksInBackground();
                }, 1000);
            } else {
                // 没有缓存，正常加载
                this.loadBooks();
            }
        } catch (error) {
            console.error('检查缓存失败:', error);
            this.loadBooks();
        }
    },

    // 后台刷新书籍数据
    async refreshBooksInBackground() {
        try {
            console.log('后台刷新书籍数据');
            const books = await this.fetchBooks();

            if (books && books.length > 0) {
                await this.loadBooksProgressively(books);

                // 更新数据
                this.allBooks = books;

                // 重新渲染书籍列表
                this.renderBooks(this.allBooks);
                this.updateBooksCount();

                // 缓存数据
                this.cacheBooksData(books);

                console.log('后台刷新完成');
            }
        } catch (error) {
            console.warn('后台刷新失败:', error);
        }
    },

    // 绑定事件
    bindEvents() {
        // 错误重试按钮
        const errorRetryBtn = Utils.dom.$('#errorRetryBtn');
        const errorCloseBtn = Utils.dom.$('#errorCloseBtn');

        if (errorRetryBtn) {
            Utils.dom.on(errorRetryBtn, 'click', () => {
                Utils.error.hide();
                this.loadBooks();
            });
        }

        if (errorCloseBtn) {
            Utils.dom.on(errorCloseBtn, 'click', () => {
                Utils.error.hide();
            });
        }





        // 监听窗口大小变化
        Utils.dom.on(window, 'resize', Utils.debounce(() => {
            this.handleResize();
        }, 250));
    },





    // 更新书籍数量显示
    updateBooksCount() {
        if (this.booksCount) {
            const total = this.allBooks.length;
            this.booksCount.textContent = `${total} 本期刊`;
        }
    },



    // 加载书籍列表
    async loadBooks() {
        try {
            this.showLoading();
            this.updateLoadingText('正在扫描期刊目录...');

            // 获取书籍数据
            const books = await this.fetchBooks();

            if (books && books.length > 0) {
                this.updateLoadingText('正在加载期刊信息...');

                // 渐进式加载书籍信息
                await this.loadBooksProgressively(books);

                // 保存所有书籍数据
                this.allBooks = books;

                this.renderBooks(this.allBooks);
                this.showBooks();

                // 保存书籍列表到本地缓存
                this.cacheBooksData(books);

                console.log(`成功加载 ${books.length} 本期刊`);
            } else {
                this.showEmpty();
            }
        } catch (error) {
            console.error('加载书籍列表失败:', error);
            this.showError(error);
        }
    },

    // 渐进式加载书籍信息
    async loadBooksProgressively(books) {
        // 快速显示书籍列表，然后在后台获取详细信息
        for (let i = 0; i < books.length; i++) {
            const book = books[i];
            this.updateLoadingText(`正在加载《${book.title}》...`);

            try {
                // 只获取基本信息，不获取页数（避免卡住）
                await this.loadBookBasicInfo(book);

                // 更新进度
                const progress = ((i + 1) / books.length) * 100;
                this.updateLoadingProgress(progress);

                // 小延迟以显示进度
                await new Promise(resolve => setTimeout(resolve, 100));
            } catch (error) {
                console.warn(`加载书籍基本信息失败: ${book.title}`, error);
            }
        }

        // 在后台异步获取页数信息
        this.loadPageCountsInBackground(books);
    },

    // 加载书籍基本信息（不包括页数）
    async loadBookBasicInfo(book) {
        try {
            // 检查本地缓存
            const cachedInfo = this.getCachedBookInfo(book.id);
            if (cachedInfo && this.isCacheValid(cachedInfo)) {
                Object.assign(book, cachedInfo);
                return;
            }

            // 如果没有文件大小信息，尝试获取
            if (!book.fileSize) {
                try {
                    const response = await fetch(`pdfs/${book.filename}`, { method: 'HEAD' });
                    if (response.ok) {
                        const contentLength = response.headers.get('content-length');
                        if (contentLength) {
                            book.fileSize = parseInt(contentLength);
                        }

                        const lastModified = response.headers.get('last-modified');
                        if (lastModified) {
                            book.lastModified = new Date(lastModified);
                        }
                    }
                } catch (error) {
                    console.warn(`获取文件信息失败: ${book.filename}`, error);
                }
            }

        } catch (error) {
            console.warn(`获取书籍基本信息失败: ${book.title}`, error);
        }
    },

    // 在后台加载页数信息
    async loadPageCountsInBackground(books) {
        console.log('开始在后台获取页数信息');

        for (const book of books) {
            try {
                // 异步获取页数，不阻塞主流程
                setTimeout(async () => {
                    try {
                        await this.getBookPageCount(book);
                        // 更新界面显示
                        this.updateBookCardPageCount(book);
                        // 缓存信息
                        this.cacheBookInfo(book);
                    } catch (error) {
                        console.warn(`后台获取页数失败: ${book.title}`, error);
                    }
                }, Math.random() * 2000); // 随机延迟，避免同时请求
            } catch (error) {
                console.warn(`后台页数获取设置失败: ${book.title}`, error);
            }
        }
    },

    // 更新书籍卡片的页数显示
    updateBookCardPageCount(book) {
        const bookCard = Utils.dom.$(`[data-book-id="${book.id}"]`);
        if (bookCard) {
            const pagesElement = bookCard.querySelector('.book-pages span:last-child');
            if (pagesElement && book.pages > 0) {
                pagesElement.textContent = `${book.pages} 页`;
            }
        }
    },

    // 加载单本书籍详细信息
    async loadBookDetails(book) {
        try {
            // 检查本地缓存
            const cachedInfo = this.getCachedBookInfo(book.id);
            if (cachedInfo && this.isCacheValid(cachedInfo)) {
                Object.assign(book, cachedInfo);
                return;
            }

            // 获取文件信息
            const response = await fetch(`pdfs/${book.filename}`, { method: 'HEAD' });
            if (response.ok) {
                const contentLength = response.headers.get('content-length');
                if (contentLength) {
                    book.fileSize = parseInt(contentLength);
                }

                // 获取最后修改时间
                const lastModified = response.headers.get('last-modified');
                if (lastModified) {
                    book.lastModified = new Date(lastModified);
                }
            }

            // 获取页数
            if (typeof pdfjsLib !== 'undefined') {
                await this.getBookPageCount(book);
            }

            // 缓存书籍信息
            this.cacheBookInfo(book);

        } catch (error) {
            console.warn(`获取书籍详情失败: ${book.title}`, error);
        }
    },

    // 更新加载文本
    updateLoadingText(text) {
        const loadingText = Utils.dom.$('.loading-text');
        if (loadingText) {
            loadingText.textContent = text;
        }
    },

    // 更新加载进度
    updateLoadingProgress(percent) {
        // 在加载容器中添加进度条
        let progressContainer = Utils.dom.$('.loading-progress');
        if (!progressContainer) {
            progressContainer = document.createElement('div');
            progressContainer.className = 'loading-progress';
            progressContainer.innerHTML = `
                <div class="progress-bar">
                    <div class="progress-fill" style="width: 0%"></div>
                </div>
                <span class="progress-text">0%</span>
            `;

            const loadingContainer = this.loadingContainer;
            if (loadingContainer) {
                loadingContainer.appendChild(progressContainer);
            }
        }

        const progressFill = progressContainer.querySelector('.progress-fill');
        const progressText = progressContainer.querySelector('.progress-text');

        if (progressFill) {
            progressFill.style.width = percent + '%';
        }
        if (progressText) {
            progressText.textContent = Math.round(percent) + '%';
        }
    },

    // 动态获取书籍数据
    async fetchBooks() {
        try {
            console.log('开始扫描pdfs文件夹...');

            // 首先尝试通过目录列表获取PDF文件
            let pdfFiles = await this.getPDFFileList();

            // 如果无法获取目录列表，使用备用方法
            if (pdfFiles.length === 0) {
                console.log('尝试备用扫描方法...');
                pdfFiles = await this.getFallbackPDFList();
            }

            const availableBooks = [];

            // 验证每个PDF文件并获取详细信息
            for (const pdfFile of pdfFiles) {
                try {
                    const response = await fetch(`pdfs/${pdfFile.filename}`, { method: 'HEAD' });

                    if (response.ok) {
                        // 获取文件大小
                        const contentLength = response.headers.get('content-length');
                        if (contentLength) {
                            pdfFile.fileSize = parseInt(contentLength);
                        }

                        // 获取最后修改时间
                        const lastModified = response.headers.get('last-modified');
                        if (lastModified) {
                            pdfFile.lastModified = new Date(lastModified);
                            pdfFile.publishDate = new Date(lastModified).toISOString().split('T')[0];
                        }

                        pdfFile.pages = 0; // 默认值，稍后更新
                        pdfFile.status = 'available';
                        availableBooks.push(pdfFile);
                        console.log(`发现可用书籍: ${pdfFile.title} (${pdfFile.filename})`);
                    } else {
                        console.warn(`PDF文件不存在: ${pdfFile.filename} (状态: ${response.status})`);
                    }
                } catch (error) {
                    console.warn(`检查PDF文件失败: ${pdfFile.filename}`, error);
                }
            }

            if (availableBooks.length === 0) {
                console.warn('未找到任何可用的PDF文件');
                // 返回一个示例条目，提示用户添加PDF文件
                return [{
                    id: 'no-pdfs-found',
                    title: '未找到PDF文件',
                    description: '请在pdfs文件夹中添加PDF文件，文件名将作为期刊标题显示。',
                    filename: '',
                    cover: 'assets/images/default-cover.svg',
                    pages: 0,
                    publishDate: new Date().toISOString().split('T')[0],
                    status: 'empty',
                    fileSize: 0
                }];
            }

            console.log(`扫描完成，找到 ${availableBooks.length} 个PDF文件`);
            return availableBooks;
        } catch (error) {
            console.error('获取书籍数据失败:', error);
            throw new Error('无法获取书籍列表');
        }
    },

    // 通过目录列表获取PDF文件
    async getPDFFileList() {
        try {
            const response = await fetch('pdfs/');
            if (!response.ok) {
                throw new Error(`HTTP ${response.status}`);
            }

            const text = await response.text();

            // 解析HTML响应，提取PDF文件链接
            const parser = new DOMParser();
            const doc = parser.parseFromString(text, 'text/html');
            const links = doc.querySelectorAll('a[href$=".pdf"], a[href*=".pdf"]');

            const pdfFiles = [];

            for (const link of links) {
                const href = link.getAttribute('href');
                if (href && href.endsWith('.pdf')) {
                    const filename = href.includes('/') ? href.split('/').pop() : href;
                    const id = filename.replace('.pdf', '');

                    pdfFiles.push({
                        id: id,
                        title: id, // 直接使用文件名（不含扩展名）作为标题
                        description: `《缙青年》电子期刊 - ${id}`,
                        filename: filename,
                        cover: await this.getCoverImage(id), // 动态获取封面
                        publishDate: new Date().toISOString().split('T')[0],
                        status: 'new',
                        fileSize: 0
                    });
                }
            }

            console.log(`通过目录列表找到 ${pdfFiles.length} 个PDF文件`);
            return pdfFiles;

        } catch (error) {
            console.warn('无法通过目录列表获取PDF文件:', error);
            return [];
        }
    },

    // 备用方法：尝试常见的PDF文件名
    async getFallbackPDFList() {
        console.log('使用备用扫描方法...');

        const commonNames = [
            // 常见的期刊命名模式
            'jinyouth1', 'jinyouth2', 'jinyouth3', 'jinyouth4', 'jinyouth5',
            'jinyouth-1', 'jinyouth-2', 'jinyouth-3', 'jinyouth-4', 'jinyouth-5',
            'jinyouth-issue1', 'jinyouth-issue2', 'jinyouth-issue3', 'jinyouth-issue4', 'jinyouth-issue5',
            'issue1', 'issue2', 'issue3', 'issue4', 'issue5',
            '第一期', '第二期', '第三期', '第四期', '第五期',
            '《缙青年》第一期', '《缙青年》第二期', '《缙青年》第三期', '《缙青年》第四期', '《缙青年》第五期'
        ];

        const availablePDFs = [];

        for (const name of commonNames) {
            try {
                const response = await fetch(`pdfs/${name}.pdf`, { method: 'HEAD' });
                if (response.ok) {
                    availablePDFs.push({
                        id: name,
                        title: name, // 直接使用文件名作为标题
                        description: `《缙青年》电子期刊 - ${name}`,
                        filename: `${name}.pdf`,
                        cover: await this.getCoverImage(name), // 动态获取封面
                        publishDate: new Date().toISOString().split('T')[0],
                        status: 'new',
                        fileSize: 0
                    });
                    console.log(`备用扫描找到: ${name}.pdf`);
                }
            } catch (error) {
                // 文件不存在，跳过
                continue;
            }
        }

        console.log(`备用扫描完成，找到 ${availablePDFs.length} 个PDF文件`);
        return availablePDFs;
    },

    // 获取封面图片
    async getCoverImage(bookId) {
        // 尝试的封面图片格式
        const coverFormats = ['.png', '.jpg', '.jpeg', '.webp'];

        for (const format of coverFormats) {
            try {
                const coverPath = `covers/${bookId}${format}`;
                const response = await fetch(coverPath, { method: 'HEAD' });

                if (response.ok) {
                    console.log(`找到封面图片: ${coverPath}`);
                    return coverPath;
                }
            } catch (error) {
                // 继续尝试下一个格式
                continue;
            }
        }

        // 如果没有找到对应的封面图片，使用默认封面
        console.log(`未找到 ${bookId} 的封面图片，使用默认封面`);
        return 'assets/images/default-cover.svg';
    },

    // 获取书籍页数
    async getBookPageCount(book) {
        try {
            // 检查PDF.js是否可用
            if (typeof pdfjsLib === 'undefined') {
                console.warn('PDF.js未加载，无法获取页数');
                book.pages = 0;
                return;
            }

            console.log(`开始获取页数: ${book.filename}`);

            const loadingTask = pdfjsLib.getDocument({
                url: `pdfs/${book.filename}`,
                // 只加载文档信息，不加载页面内容
                disableStream: false,
                disableRange: false,
                // 添加错误处理配置
                verbosity: pdfjsLib.VerbosityLevel.ERRORS
            });

            // 添加超时处理
            const timeoutPromise = new Promise((_, reject) => {
                setTimeout(() => reject(new Error('PDF加载超时')), 3000);
            });

            const pdfDoc = await Promise.race([loadingTask.promise, timeoutPromise]);
            book.pages = pdfDoc.numPages;

            // 清理资源
            pdfDoc.destroy();

            console.log(`${book.title}: ${book.pages}页`);
        } catch (error) {
            console.warn(`获取页数失败: ${book.filename}`, error);
            book.pages = 0;
        }
    },

    // 渲染书籍列表
    renderBooks(books) {
        if (!this.booksGrid) return;

        // 按名称倒序排列（Z到A）
        const sortedBooks = [...books].sort((a, b) => {
            return b.title.localeCompare(a.title, 'zh-CN');
        });

        const booksHtml = sortedBooks.map(book => this.createBookCard(book)).join('');
        this.booksGrid.innerHTML = booksHtml;

        // 绑定书籍点击事件
        this.bindBookEvents();
    },

    // 创建书籍卡片（简化版）
    createBookCard(book) {
        return `
            <div class="book-card" data-book-id="${book.id}" tabindex="0" role="button" aria-label="打开${book.title}">
                <div class="book-cover">
                    ${book.cover ?
                        `<img class="book-cover-image" src="${book.cover}" alt="${book.title}封面" loading="lazy">` :
                        `<div class="book-cover-placeholder">📖</div>`
                    }
                </div>
                <div class="book-info">
                    <h3 class="book-title">${book.title}</h3>
                </div>
            </div>
        `;
    },

    // 绑定书籍事件
    bindBookEvents() {
        const bookCards = Utils.dom.$$('.book-card');
        
        bookCards.forEach(card => {
            // 点击事件
            Utils.dom.on(card, 'click', (e) => {
                e.preventDefault();
                this.openBook(card.dataset.bookId);
            });

            // 键盘事件
            Utils.dom.on(card, 'keydown', (e) => {
                if (e.key === 'Enter' || e.key === ' ') {
                    e.preventDefault();
                    this.openBook(card.dataset.bookId);
                }
            });

            // 触摸反馈
            if (Utils.responsive.isTouchDevice()) {
                Utils.dom.on(card, 'touchstart', (e) => {
                    Utils.dom.addClass(card, 'touching');
                });

                Utils.dom.on(card, 'touchend', (e) => {
                    Utils.dom.removeClass(card, 'touching');
                });
            }
        });
    },

    // 打开书籍
    openBook(bookId) {
        try {
            // 保存阅读历史
            this.saveReadingHistory(bookId);
            
            // 跳转到阅读器
            Utils.navigation.goToReader(bookId);
        } catch (error) {
            console.error('打开书籍失败:', error);
            Utils.error.show(
                '打开失败',
                '无法打开该电子书，请稍后重试',
                ['检查网络连接', '刷新页面重试', '联系技术支持'],
                () => this.openBook(bookId)
            );
        }
    },

    // 保存阅读历史
    saveReadingHistory(bookId) {
        try {
            const history = Utils.storage.get('readingHistory', []);
            const existingIndex = history.findIndex(item => item.bookId === bookId);
            
            const historyItem = {
                bookId,
                lastRead: new Date().toISOString(),
                readCount: existingIndex >= 0 ? history[existingIndex].readCount + 1 : 1
            };

            if (existingIndex >= 0) {
                history[existingIndex] = historyItem;
            } else {
                history.unshift(historyItem);
            }

            // 只保留最近20条记录
            if (history.length > 20) {
                history.splice(20);
            }

            Utils.storage.set('readingHistory', history);
        } catch (error) {
            console.error('保存阅读历史失败:', error);
        }
    },

    // 显示加载状态
    showLoading() {
        if (this.loadingContainer) Utils.dom.show(this.loadingContainer);
        if (this.booksContainer) Utils.dom.hide(this.booksContainer);
        if (this.emptyState) Utils.dom.hide(this.emptyState);
    },

    // 显示书籍列表
    showBooks() {
        if (this.loadingContainer) Utils.dom.hide(this.loadingContainer);
        if (this.booksContainer) Utils.dom.show(this.booksContainer);
        if (this.emptyState) Utils.dom.hide(this.emptyState);
        if (this.searchContainer) Utils.dom.show(this.searchContainer);

        // 更新书籍数量
        this.updateBooksCount();
    },

    // 显示空状态
    showEmpty() {
        if (this.loadingContainer) Utils.dom.hide(this.loadingContainer);
        if (this.booksContainer) Utils.dom.hide(this.booksContainer);
        if (this.emptyState) Utils.dom.show(this.emptyState);
    },

    // 显示错误
    showError(error) {
        if (this.loadingContainer) Utils.dom.hide(this.loadingContainer);
        if (this.booksContainer) Utils.dom.hide(this.booksContainer);
        if (this.emptyState) Utils.dom.hide(this.emptyState);

        Utils.error.show(
            '加载失败',
            '无法加载期刊列表，请检查网络连接后重试',
            [
                '检查网络连接是否正常',
                '刷新页面重新加载',
                '清除浏览器缓存后重试'
            ],
            () => this.loadBooks()
        );
    },

    // 缓存书籍数据
    cacheBooksData(books) {
        try {
            const cacheData = {
                books: books,
                timestamp: Date.now(),
                version: '1.0'
            };
            Utils.storage.set('booksCache', cacheData);
        } catch (error) {
            console.warn('缓存书籍数据失败:', error);
        }
    },

    // 获取缓存的书籍数据
    getCachedBooksData() {
        try {
            const cacheData = Utils.storage.get('booksCache', null);
            if (cacheData && this.isCacheValid(cacheData)) {
                return cacheData.books;
            }
        } catch (error) {
            console.warn('读取缓存失败:', error);
        }
        return null;
    },

    // 缓存单本书籍信息
    cacheBookInfo(book) {
        try {
            const cacheKey = `book_${book.id}`;
            const cacheData = {
                pages: book.pages,
                fileSize: book.fileSize,
                lastModified: book.lastModified,
                timestamp: Date.now()
            };
            Utils.storage.set(cacheKey, cacheData);
        } catch (error) {
            console.warn('缓存书籍信息失败:', error);
        }
    },

    // 获取缓存的书籍信息
    getCachedBookInfo(bookId) {
        try {
            const cacheKey = `book_${bookId}`;
            return Utils.storage.get(cacheKey, null);
        } catch (error) {
            console.warn('读取书籍缓存失败:', error);
            return null;
        }
    },

    // 检查缓存是否有效
    isCacheValid(cacheData) {
        if (!cacheData || !cacheData.timestamp) return false;

        // 缓存有效期：24小时
        const cacheAge = Date.now() - cacheData.timestamp;
        const maxAge = 24 * 60 * 60 * 1000; // 24小时

        return cacheAge < maxAge;
    },

    // 清理过期缓存
    cleanExpiredCache() {
        try {
            const keys = Object.keys(localStorage);
            for (const key of keys) {
                if (key.startsWith('book_') || key === 'booksCache') {
                    const data = Utils.storage.get(key, null);
                    if (data && !this.isCacheValid(data)) {
                        Utils.storage.remove(key);
                        console.log(`清理过期缓存: ${key}`);
                    }
                }
            }
        } catch (error) {
            console.warn('清理缓存失败:', error);
        }
    },

    // 处理窗口大小变化
    handleResize() {
        // 响应式处理逻辑
        const isMobile = Utils.responsive.isMobile();
        document.body.classList.toggle('mobile', isMobile);

        // 重新布局书籍网格
        this.adjustBooksGrid();
    },

    // 调整书籍网格布局
    adjustBooksGrid() {
        if (!this.booksGrid) return;

        const containerWidth = this.booksGrid.parentElement.clientWidth;
        const cardMinWidth = 280;
        const gap = 24;

        const columns = Math.floor((containerWidth + gap) / (cardMinWidth + gap));
        const actualColumns = Math.max(1, columns);

        this.booksGrid.style.gridTemplateColumns = `repeat(${actualColumns}, 1fr)`;
    }
};

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', () => {
    BookListManager.init();
});

// 导出到全局
window.BookListManager = BookListManager;
